/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package edu.upf.grupE.impl;

import edu.upf.grupE.Controller.AlbumController;
import edu.upf.grupE.Controller.PictureController;
import edu.upf.grupE.Entities.Album;
import edu.upf.grupE.Entities.FileDescriptor;
import edu.upf.grupE.Entities.Picture;
import edu.upf.grupE.Listener;
import java.awt.Graphics;
import java.awt.GraphicsConfiguration;
import java.awt.GraphicsDevice;
import java.awt.GraphicsEnvironment;
import java.awt.HeadlessException;
import java.awt.Image;
import java.awt.Transparency;
import java.awt.image.BufferedImage;
import java.awt.image.ColorModel;
import java.awt.image.PixelGrabber;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.ImageIcon;
import org.jivesoftware.smack.packet.Message;
import org.jivesoftware.smack.packet.Packet;

/**
 *
 * @author xday666
 */
public class DownloadResultListener implements Listener {

    private IM im;

    /**
     *
     * @param instancem
     */
    public DownloadResultListener(final IM instancem) {
        im = instancem;
    }

    /**
     * we only work with the packets that are Messages. then we create a new Message
     * that will be the response to the search profile Message.
     * To be sure that the information that arrives to this listener is correct, we
     * print it into the Text Box.
     * Later we send back to the origin a Message containing the same object received.
     * @param packet
     */
    public final void processPacket(final Packet packet) {
        if (packet instanceof Message) {

            System.out.println("Recibimos una foto!!");

            Message msg = (Message) packet;

            Picture pic = (Picture) msg.getProperty("DownloadResultPic");
            byte[] bytes = (byte[]) msg.getProperty("image");

            //BufferedImage bi = ImageIO.


            //BufferedImage bi;
            StringBuffer sb = new StringBuffer();
            sb.append("downloaded" + File.separatorChar);
            String path = pic.getFileDescriptor().getPath();
            if(path.indexOf("/")>-1){
               sb.append(path.substring(path.lastIndexOf("/")+1));
            }else{
               sb.append(path.substring(path.lastIndexOf("\\")+1));
            }
            
            System.out.println(sb.toString());

            try {
                FileOutputStream fos = new FileOutputStream(sb.toString());
                fos.write(bytes);

            } catch (IOException ex) {
                Logger.getLogger(DownloadResultListener.class.getName()).log(Level.SEVERE, null, ex);
            }
            //Image img = icon.getImage();
            //bi = toBufferedImage(img);
           /* try {
                ImageIO.write(bi, "png", f);
            } catch (IOException ex) {
                Logger.getLogger(DownloadResultListener.class.getName()).log(Level.SEVERE, null, ex);
            }*/


            pic.deleteId();
            FileDescriptor tmpfiledesc = pic.getFileDescriptor();
            tmpfiledesc.setPath(sb.toString());
            pic = PictureController.getById(PictureController.createOrUpdate(pic));
            Album down = AlbumController.getById(1L);
            down.addPicture(pic.getId());
            AlbumController.createOrUpdate(down);
            im.el.refreshListPicture();

        }
    }

    // This method returns a buffered image with the contents of an image
    public static BufferedImage toBufferedImage(Image image) {
        if (image instanceof BufferedImage) {
            return (BufferedImage) image;
        }

        // This code ensures that all the pixels in the image are loaded
        image = new ImageIcon(image).getImage();

        // Determine if the image has transparent pixels; for this method's
        // implementation, see e661 Determining If an Image Has Transparent Pixels
        boolean hasAlpha = hasAlpha(image);

        // Create a buffered image with a format that's compatible with the screen
        BufferedImage bimage = null;
        GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
        try {
            // Determine the type of transparency of the new buffered image
            int transparency = Transparency.OPAQUE;
            if (hasAlpha) {
                transparency = Transparency.BITMASK;
            }

            // Create the buffered image
            GraphicsDevice gs = ge.getDefaultScreenDevice();
            GraphicsConfiguration gc = gs.getDefaultConfiguration();
            bimage = gc.createCompatibleImage(
                    image.getWidth(null), image.getHeight(null), transparency);
        } catch (HeadlessException e) {
            // The system does not have a screen
        }

        if (bimage == null) {
            // Create a buffered image using the default color model
            int type = BufferedImage.TYPE_INT_RGB;
            if (hasAlpha) {
                type = BufferedImage.TYPE_INT_ARGB;
            }
            bimage = new BufferedImage(image.getWidth(null), image.getHeight(null), type);
        }

        // Copy image to buffered image
        Graphics g = bimage.createGraphics();

        // Paint the image onto the buffered image
        g.drawImage(image, 0, 0, null);
        g.dispose();

        return bimage;
    }

    // This method returns true if the specified image has transparent pixels
    public static boolean hasAlpha(Image image) {
        // If buffered image, the color model is readily available
        if (image instanceof BufferedImage) {
            BufferedImage bimage = (BufferedImage) image;
            return bimage.getColorModel().hasAlpha();
        }

        // Use a pixel grabber to retrieve the image's color model;
        // grabbing a single pixel is usually sufficient
        PixelGrabber pg = new PixelGrabber(image, 0, 0, 1, 1, false);
        try {
            pg.grabPixels();
        } catch (InterruptedException e) {
        }

        // Get the image's color model
        ColorModel cm = pg.getColorModel();
        return cm.hasAlpha();
    }
}
